 La version numrique du sujet fournie en fichier texte (format *.txt) doit tre ouverte en tant que braille informatique. Elle sera affiche en braille 6 points. Lapplication  bloc-notes  des ordinateurs courants, ou des logiciels spcialiss peuvent tre utiliss.  dfaut, reportez-vous  la version en papier. 
Le candidat doit rdiger ses rponses sur un second fichier, et peut demander  un assistant ou  un secrtaire de recopier sa production de faon manuscrite sur une copie.
Un fichier en format *.pdf est galement fourni.
La page du document originale est indique par  PO 1  pour  page originale n1 . Les rfrences aux pages braille (sommaire, rfrences en cours de sujet) font rfrence au sujet braille imprim. 

po `1
`24-nsij`1me1
braille intgral
baccalaurat gnral
preuve d'enseignement de spcialit
session `2024
numrique et sciences informatiques
preuve du mercredi `19 juin `2024
dure de l'preuve: `3 heures `30
volume `1 sujet  l'usage de la calculatrice n'est pas autoris.
ds que ce sujet vous est remis, assurez-vous qu'il est complet.
ce sujet comporte `15 pages numrotes de `1  `15 dans la version originale. la version en braille intgral est compose de deux volumes:
9o le sujet comportant `47 pages numrotes de `1  `47 9o une annexe de `5 planches tactiles.  l'ensemble des planches tactiles est propos sur papier thermogonfl. une feuille plastique vierge est  disposition du candidat brailliste pour l'exercice `3 partie c, question `8.
le sujet est compos de trois exercices indpendants.
le candidat traite les trois exercices.
sommaire  exercice `1 `4
exercice `2 `14
partie a `15
partie b `18
partie c `21
exercice `3 `23
partie a: la classe chien `24
partie b: la classe equipe `29
partie c: classement  l'issue d'une tape `36  partie d: classement gnral `43 po `2
exercice `1 exercice `1 (`6 points)  cet exercice porte sur la programmation objet en python et les graphes.
nous avons reprsent sous la forme d'un graphe les liens entre cinq diffrents sites web:
figure `1: graphe avec `5 sites  `;voir planche tactile no`1'  la valeur de chaque ar2te reprsente le nombre de citations (de liens hypertextes) d'un site vers un autre. ainsi, le site site`4 contient `6 liens hypertextes qui renvoient vers le site site`5.
les sites sont reprsents par des objets de la classe ?site* dont le code est partiellement donn ci-dessous. la compltion de la mthode ?calculpopularite* fera l'objet d'une question ultrieure
`1 class site:
`2
`3 def --init--(self,  nom):
`4 self.nom `" nom
`5 self.predecesseurs
`" ()b
`6 self.successeurs
`" ()b
`7 self.popularite `" `0 `8 self.couleur
`" 'blanche'
`9
`10 def calcul
popularite(self):
`11 ... po `3
le graphe prcdent peut alors 2tre reprsent ainsi:
`1 0 description du graphe `2 s`1, s`2, s`3, s`4, s`5   `" site('site`1'), site('site`2'), site('site`3'), site('site`4'), site('site`5')
`3 s`1.successeurs 
`" ((s`3,3), (s`4,1), (s`5,3))b
`4 s`2.successeurs 
`" ((s`1,4), (s`3,5), (s`4,2))b
`5 s`3.successeurs 
`" ((s`5,3))b
`6 s`4.successeurs 
`" ((s`1,2), (s`5,6))b `7 s`5.successeurs 
`" ((s`3,4))b
`8 s`1.predecesseurs 
`" ((s`2,4), (s`4,2))b `9 s`2.predecesseurs `" ()b `10 s`3.predecesseurs 
`" ((s`1,3), (s`2,5), (s`5,4))b
`11 s`4.predecesseurs `" ... `12 s`5.predecesseurs `" ...  `1. expliquer la ligne `9 de ce code.
`2. les lignes `11 et `12 de cette description du graphe ne sont pas compltes. recopier et complter le code des lignes `11 et `12. `3. donner et expliquer la valeur de l'expression suivante: ?s`2.successeurs(`1)b(`1)b*   pour mesurer la pertinence d'un site, on commence par lui attribuer un nombre appel valeur de popularit qui correspond au nombre de fois qu'il est cit dans les autres sites, c'est--dire le nombre de liens hypertextes qui renvoient sur lui.
par exemple, la valeur de popularit du site site`4 est `3.
`4. donner, selon cette dfinition, la valeur de popularit du site site`1. `5. crire sur votre copie le code de la mthode ?calculpopularite* de la classe ?site* qui affecte  l'attribut ?popularite* la valeur de popularit correspondante et renvoie cet attribut.
afin de calculer cette valeur de popularit pour chacun des sites, nous allons faire un parcours dans le graphe de faon  excuter la mthode ?calculpopularite* pour chacun des objets.
po `4
voici le code de la fonction qui permet le parcours du graphe:
`1 def parcoursgraphe( 
sommetdepart):
`2 parcours `" ()b
`3 sommetdepart.couleur   `" 'noire'
`4 listes `" ()b
`5 listes.append( 
sommetdepart)
`6 while len(listes) 
!`" `0:
`7 site 
`" listes.pop(`0)
`8 site 
.calculpopularite() `9 parcours.append(site) `10 for successeur in
site.successeurs:
`11 if successeur(`0)b  .couleur `"" 
'blanche':
`12 successeur(`0)b  .couleur 
`" 'noire'
`13 listes.append(   successeur(`0)b) `14 return parcours on rappelle les points suivants:
9o la mthode ?append* ajoute un lment  une liste python; par exemple, ?tab.append(el)* permet d'ajouter l'lment ?el*  la liste python ?tab*;
9o la mthode ?pop* enlve de la liste l'lment situ  la position indique et le renvoie en valeur de retour; par exemple, ?tab.pop(`2)* enlve l'lment  l'indice ?`2* et le renvoie.
dans ce parcours, les sites non encore traits sont de couleur '?blanche*' (valeur par dfaut  la cration de l'objet) et ceux qui sont traits de couleur '?noire*'.
`6. dans ce parcours, on manipule la liste python nomme ?listes* uniquement  l'aide d'appels de la forme ?listes.append(sommet)* et ?listes.pop(`0)*.
donner la structure de donnes correspondant  ces manipulations.
`7. donner le nom de ce parcours de graphe.
`8. la fonction ?parcoursgraphe* renvoie une liste parcours. indiquer la valeur renvoye par l'appel de fonction: ?parcoursgraphe(s`1)* po `5
on cherche maintenant le site le plus populaire, celui dont la valeur de popularit est la plus grande.
voici le code de la fonction qui renvoie le site le plus populaire, elle prend comme argument une liste non vide contenant des instances de la classe ?site*.
`1 def lepluspopulaire
(listesites):
`2 maxpopularite `" `0
`3 sitelepluspopulaire   `" listesites(`0)b
`4 for site in listesites: `5 if site.popularite
@ maxpopularite:
`6 ...
`7 ...
`8 return siteleplus
populaire
`9. copier et complter les lignes `6 et `7 de cette fonction.
`10. donner ce que renvoie la ligne de code suivante: ?lepluspopulaire(
parcoursgraphe(s`1)).nom* `11. on envisage d'utiliser l'ensemble des fonctions proposes ci-dessus pour rechercher le site le plus populaire parmi un trs grand nombre de sites (quelques milliers de sites). expliquer si ce code est adapt  une telle quantit de sites  traiter. justifier votre rponse. po `6
exercice `2 exercice `2 (`6 points)  cet exercice traite de protocoles de routage, de scurit des communications et de base de donnes relationnelle.
une agence de voyage propose des croisires en bateau. chaque croisire a un nom unique et passe par quatre escales correspondant  des villes qui ont elles aussi des noms diffrents.
pour grer les rservations de ses clients, l'agence utilise une base de donnes. voici la description des trois relations de cette base dont les cls primaires ont t soulignes et les cls trangres indiques par un 0:
`;voir planche tactile no`2'  remarque: l'nonc de cet exercice utilise tout ou une partie des mots suivants du langage sql: ?:select, from, where, join on, insert into, values, update set, or, and*.  partie a  l'agence de voyage possde deux bureaux distincts.
elle passe par un prestataire de service qui hberge sa base de donnes et utilise un systme de gestion de base de donnes relationnelle.
vous trouverez ci-aprs un schma du rseau entre les deux bureaux de l'agence de voyage et le prestataire.
on peut y voir les diffrents routeurs (nomms de a  i) ainsi que le co5t des liaisons entre eux. po `7
figure `1: topologie du rseau
`;voir planche tactile no`3'  `1. donner deux services rendus par un systme de gestion de bases de donnes relationnelles.  le protocole rip (routing information protocol) est un protocole de routage qui minimise le nombre de routeurs par lesquels les paquets transitent.
le protocole ospf (open shortest path first) est un protocole de routage qui minimise le co5t du transit des paquets.
`2. donner la route suivie par une requ2te issue du bureau numro `1 jusqu'au prestataire si on utilise le protocole rip.
`3. donner les deux routes que pourrait suivre une requ2te issue du bureau numro `2 jusqu'au prestataire si on utilise le protocole ospf. donner le co5t de chaque route.  partie b `4. expliquer pourquoi l'attribut ?id-client* a t choisi comme cl primaire dans la relation ?clients*.
po `8
`5. dfinir ce qu'est une cl trangre. donner la ou les cls trangres de chaque relation qui en a en prcisant la cl primaire qu'elles rfrencent.  l'agence a obtenu l'autorisation de faire escale dans quatre nouvelles villes: puerto saibo, puerto kifecho, puerto kifebo et puerto repo. elle souhaite crer une nouvelle croisire qui passera par ces quatre villes.
un stagiaire de l'agence demande de l'aide  une intelligence artificielle (ia):
figure `2: rponse de l'ia gggggggggggggggggggggggggggggg
pour ajouter la nouvelle croisire nomme 'croisire puerto' avec ses escales correspondantes, vous pouvez utiliser la requ2te suivante:
insert into croisieres ( nom, escale-`1, escale-`2, escale-`3, escale-`4)
values ( 'croisire puerto',
'puerto sebo',
'puerto kifecho',
'puerto kifebo',
'puerto repo');
gggggggggggggggggggggggggggggg il tape alors la requ2te propose mais obtient le message d'erreur suivant du sgbd (systmes de gestion de bases de donnes):
?foreign key constraint failed*. `6. expliquer l'erreur commise et proposer une solution.  partie c  `7. jean barc, un allemand n le `29 juin `1972, demande un geste commercial en raison de sa fidlit  l'agence. expliquer les requ2tes sql suivantes saisies par le gestionnaire:   select id
from clients
where nom `" 'barc' and prenom `" 'jean' and  date-naissance `
`" '`1972/06/29' and
pays `" 'allemagne';
select id-reservation
from reservations
where id-client `" 1243;  `8. crire les deux requ2tes de la question `7. sous la forme d'une requ2te unique. `9. un client souhaite modifier sa rservation d'identifiant `20456. il souhaite remplacer la croisire de cette rservation par la toute dernire offre de l'agence: la croisire puerto.  crire une requ2te sql qui permet de mettre  jour la base de donnes pour lui donner satisfaction.
`10. donner une requ2te sql permettant d'obtenir les noms, prnoms et dates de naissance des clients ayant choisi la croisire nomme croisire piano ou celle nomme croisire puerto.`0 po `9
exercice `3 exercice `3 (`8 points)  cet exercice porte sur la programmation oriente objet, sur les arbres binaires de recherche et la rcursivit.
chaque anne, plusieurs courses de chiens de tra3neaux sont organises sur les terrains enneigs. l'une d'elle, la traverse blanche, est une course se droulant en `9 tapes. l'organisateur de cette course est charg de crer un programme python pour aider  la bonne gestion de l'vnement.
partie a: la classe ?chien*  afin de caractriser un chien, l'organisateur dcide de crer une classe ?chien* avec les attributs suivants:
9o ?id-chien*, un nombre entier correspondant au numro attribu au chien lors de son inscription  la course;
9o ?nom*, une cha3ne de caractres correspondant au nom du chien;
9o ?role*, une cha3ne de caractres correspondant au poste occup par le chien: en fonction de sa place dans l'attelage, un chien a un r4le bien dfini et peut 2tre '?leader*', '?swing dog*', '?wheel dog*' ou '?team dog*'.
9o ?id-proprietaire*, un nombre entier correspondant au numro de l'quipe.
le code python incomplet de la classe ?chien* est donn ci-dessous.
`1 class chien:
`2 def --init--(self,  id-chien, nom, role,  id-prop):
`3 self.id-chien 
`" id-chien
`4 self.nom `" nom
`5 self.role `" role
`6 self.id-proprietaire  `" id-prop
`7 def changer-role(self,  nouveau-role):
`8 """change le r4le du  chien avec la valeur  passe en param
tre."""
`9 ...  po `10
voici un extrait des informations dont on dispose sur les chiens inscrits  la course.
`;tableau trait en colonnes.
liste des abrviations:  9o idc: id-chien
9o idp: id-proprietaire  9o wheel: wheel dog
9o team: team dog
9o swing: swing dog' idc nom  role idp `40 duke wheel `10 `41 sadie team `10 `42 zeus swing `11 `43 roxie swing `11 `44 scout team `11 `45 ginger team `11 `46 helka team `11  suite aux inscriptions, l'organisateur procde  la cration de tous les objets de type ?chien* et les stocke dans des variables en choisissant un nom explicite. ainsi, l'objet dont l'attribut id-chien a pour valeur `40 est stock dans la variable ?chien`40*.
`1. crire l'instruction permettant d'instancier l'objet ?chien`40* caractrisant le chien ayant le numro d'inscription `40. `2. selon l'tat de fatigue de ses chiens ou du profil de l'tape, le musher (nom donn  la personne qui conduit le tra3neau) peut dcider de changer le r4le des chiens dans l'attelage.  recopier et complter la mthode ?changer-role* de la classe ?chien*.
`3. le propritaire de duke dcide de lui attribuer le r4le de '?leader*'.
crire l'instruction permettant d'effectuer cette modification.  partie b: la classe ?equipe* on souhaite  prsent crer une classe ?equipe* ayant les attributs suivants:
9o ?num-dossard*, un nombre entier correspondant au numro inscrit sur le dossard du musher;
9o ?nom-equipe*, une cha3ne de caractres correspondant au nom de l'quipe;
9o ?liste-chiens*, une liste d'objets de type ?chien* dont chaque lment correspond  un chien au dpart de l'tape du jour; 9o ?temps-etape*, une cha3ne de caractres (par exemple '?`2h34*') reprsentant le temps mis par l'quipe pour parcourir l'tape du jour; 9o ?liste-temps*, une liste de cha3nes de caractres permettant de stocker les temps de l'quipe pour chacune des `9 tapes. cet attribut peut, par exemple, contenir la liste: ?('`4h36', '`3h57', '`3h09', '`5h49', '`4h45', '`3h26', '`4h57', '`5h52', '`4h31')b*.
po `11
on donne le code python suivant de la classe ?equipe*.
`1 class equipe:
`2 def --init--(self,  num-dossard,
nom-equipe):
`3 self.num-dossard   `" num-dossard
`4 self.nom-equipe 
`" nom-equipe
`5 self.liste-chiens   `" ()b
`6 self.temps-etape   `" ''
`7 self.liste-temps   `" ()b
`8 `9 def ajouter-chien(self,  chien):
`10 self.liste-chiens   .append(chien)
`11 `12 def retirer-chien(self,  numero):
`13 ...
`14 `15 def ajouter-temps-   etape(self, temps):
`16 self.liste-temps   .append(temps)
pour la premire tape, le musher de l'quipe numro `11, reprsente en python par l'objet ?eq`11*, dcide de constituer une quipe avec les quatre chiens identifis par les numros `42, `44, `45 et `46. on donne ci-dessous les instructions python permettant de crer l'quipe ?eq`11* et l'attelage constitu des `4 chiens prcdents. `1 eq`11 `" equipe(`11,
'malamutes endurants') `2 eq`11.ajouter-chien(   chien`42)
`3 eq`11.ajouter-chien(   chien`44)
`4 eq`11.ajouter-chien(   chien`45)
`5 eq`11.ajouter-chien(   chien`46)  malheureusement, le musher s'aperoit que sa chienne helka, chien numro `46, n'est pas au mieux de sa forme et il dcide de la retirer de l'attelage.
`4. recopier et complter la mthode ?retirer-chien* ayant pour paramtre ?numero*, un entier correspondant au numro attribu au chien lors de l'inscription, et permettant de mettre  jour l'attribut ?liste-chiens* aprs retrait du chien dont la valeur de l'attribut ?id-chien* est ?numero*. `5. en vous aidant de la fonction prcdente, crire l'instruction qui permet de retirer helka de l'attelage de l'quipe ?eq`11*.  on donne  prsent le code python d'une fonction ?convert* prenant pour paramtre ?chaine*, une cha3ne de caractres reprsentant une dure, donne en heure et minute.
on supposera que cette dure est toujours strictement infrieure  `10 heures, temps maximal fix par le rglement pour terminer une tape.
`1 def convert(chaine):
`2 heure-dec 
`" int(chaine(`0)b)   `! int(chaine(`2)b   `! chaine(`3)b) / `60 `3 return heure-dec po `12
`6. indiquer le rsultat renvoy par l'appel ?convert('`4h36')*.
`7. crire une fonction ?temps-course* qui prend pour paramtre ?equipe* de type ?equipe* et qui renvoie un nombre flottant correspondant au cumul des temps de l'quipe ?equipe*  l'issue des `9 tapes de la course.
on rappelle que la classe ?equipe* dispose d'un attribut ?liste-temps*.  partie c: classement  l'issue d'une tape  chaque jour,  la fin de l'tape, on dcide de construire un arbre binaire de recherche (abr) afin d'tablir le classement des quipes. chaque n9ud de cet arbre est un objet de type ?equipe*.
dans cet arbre binaire de recherche, en tout n9ud:
9o toutes les quipes du sous-arbre gauche sont strictement plus rapides que ce n9ud;
9o toutes les quipes du sous-arbre droit sont moins rapides ou sont  galit avec ce n9ud.
voici les temps, en heure et minute, relevs  l'issue de la premire tape:
`;tableau trait en colonnes' temps  l'arrive de la premire tape
quipe temps
eq`1 `4h36
eq`2 `3h57
eq`3 `3h09
eq`4 `5h49
eq`5 `4h45
eq`6 `3h26
eq`7 `4h51
eq`8 `5h52
eq`9 `4h31
eq`10 `3h44
eq`11 `4h26  dans l'arbre binaire de recherche initialement vide, on ajoute successivement, dans cet ordre, les quipes
?eq`1, eq`2, eq`3, ..., eq`11*, `11 objets de la classe ?equipe* tous construits sur le m2me modle que l'objet ?eq`11* prcdent.
`8. dans l'arbre binaire de recherche ci-dessous, les n9uds eq`1 et eq`2 ont t insrs. recopier et complter cet arbre en insrant les `9 n9uds manquants.  figure `1: premiers lments de l'abr  `;voir planche tactile no`4.
une feuille plastique vierge est  disposition du candidat brailliste pour cette question' `9. indiquer quel parcours d'arbre permet d'obtenir la liste des quipes classes de la plus rapide  la plus lente. po `13
on donne ci-dessous la classe ?n9ud*, permettant de dfinir les arbres binaires:
`1 class n9ud:
`2 def --init--(self,  equipe, gauche `"
none, droit `" none): `3 self.racine `" equipe `4 self.gauche `" gauche `5 self.droit `" droit  on donne ci-dessous le code d'une fonction ?construction-arbre* qui,  partir d'une liste d'lments de type ?n9ud* permet d'insrer successivement chaque n9ud  sa place dans l'abr.
`1 def construction-
arbre(liste):
`2 a `" n9ud(liste(`0)b) `3 for i in range(`1,len   (liste)):
`4 inserer(a, liste(i)b) `5 return a
la fonction ?construction-arbre* fait appel  la fonction ?inserer* qui prend pour paramtre ?arb*, de type ?n9ud*, et
?eq*, de type ?equipe*.
cette fonction construit le n9ud  partir de ?eq* et l'insre  sa place dans l'abr.
`1 def inserer(arb, eq):
`2 """ insertion d'une
quipe  sa place
dans un abr contenant `3 au moins un n9ud."""
`4 if convert( 
eq.temps-etape) 
2 convert(arb.racine.  temps-etape):
`5 if arb.gauche is
none:
`6 arb.gauche `" ... `7 else:
`8 inserer(..., eq)
`9 else:
`10 if arb.droit is none: `11 arb.droit 
`" n9ud(eq)
`12 else:
`13 ...  `10. expliquer en quoi la fonction ?inserer* est une fonction rcursive.
`11. recopier et complter les lignes `6, `8 et `13 de la fonction ?inserer*.
`12. recopier et complter les lignes `3 et `5 de la fonction ?est-gagnante* ci-dessous qui prend en paramtre un abr ?arbre*, de type ?n9ud*, et qui renvoie le nom de l'quipe ayant gagn l'tape.
`1 def est-gagnante(arbre): `2 if arbre.gauche `""
none:
`3 return ...
`4 else:
`5 return ...
po `14
partie d: classement gnral  on dcide d'tablir un classement gnral obtenu  partir du cumul des temps mis par chaque quipe pour parcourir l'ensemble des `9 tapes.
sur le m2me principe que l'arbre de la partie prcdente, on construit l'abr ci-dessous qui permet, gr1ce au parcours d'arbre appropri, d'tablir ce classement gnral des quipes.
figure `2: abr du classement gnral  `;voir planche tactile no`5'  le rglement prvoit la disqualification d'une quipe en cas de non-respect de celui-ci. il s'avre que l'quipe `2 et l'quipe `5 doivent 2tre disqualifies pour manquement au rglement. les n9uds ?eq`2* et ?eq`5* doivent donc 2tre supprims de l'abr prcdent.
pour supprimer un n9ud ?n* dans un abr, trois possibilits se prsentent:
9o le n9ud ?n*  supprimer est une feuille: il suffit de le retirer de l'arbre; 9o le n9ud ?n*  supprimer n'a qu'un seul fils: on relie le fils de ?n* au pre de ?n* et on supprime le n9ud ?n*;
9o le n9ud ?n*  supprimer possde deux fils: on le remplace par son successeur (l'quipe qui a le temps immdiatement suprieur) qui est toujours le minimum de ses descendants droits.
`13. dessiner le nouvel arbre de recherche ?a-final* obtenu aprs suppression des quipes ?eq`2* et ?eq`5* dans l'abr correspondant au classement gnral. l'organisateur souhaite disposer d'une fonction ?rechercher* permettant de savoir si une quipe a t disqualifie ou non. on donne les spcifications de la fonction ?rechercher,* prenant en paramtre ?arbre* et ?equipe*.
po `15
`1 def rechercher(arbre,
equipe):
`2 """
`3 paramtres
`4 ggggggggg
`5 arbre: un abr, non
vide, de type n9ud,
reprsentant le
`6 classement gnral.
`7 equipe: un lment, de  type equipe, dont on  veut dterminer
`8 l'appartenance ou non   l'abr arbre.
`9 rsultat
`10 ggggggggg
`11 cette fonction renvoie  true si equipe est un  n9ud de arbre,
`12 false sinon.
`13 """
`14 ...  pour cette fonction
(?a-final* dsigne l'arbre obtenu  la question `13, aprs suppression des quipes `2 et `5):
9o l'appel ?rechercher(a-final, eq`1)* renvoie ?true*;
9o l'appel ?rechercher(a-final, eq`2)* renvoie ?false*.
`14. crire le code de la fonction ?rechercher*.

